﻿using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Data.OleDb;
using System.Data.SqlClient;
using System.Linq;
using System.Web;
using System.IO;
using System.Drawing;
using System.Drawing.Imaging;
using System.Drawing.Drawing2D;
using System.Security.Cryptography;
using System.Text;

namespace milanov
{
    //Thom/Eden/Jacco
    public class Fotos
    {
        public static string file(string filename, int sizefile, int width, int height, string name, string comment, string categorie, DateTime time, decimal prijs)
        {
            using (SqlConnection con = new SqlConnection(ConfigurationManager.ConnectionStrings["fotosDB"].ConnectionString))
            {
                con.Open();
                string inse = "insert into [Fotos]  values(@Filename, @Name, @Comment, @Category, @Filesize, @Width, @Height, @Uploadtime, @Price)";
                using (SqlCommand add = new SqlCommand(inse, con))
                {
                    add.Parameters.AddWithValue("@Filename", filename);
                    add.Parameters.AddWithValue("@Name", name);
                    add.Parameters.AddWithValue("@Comment", comment);
                    add.Parameters.AddWithValue("@Filesize", sizefile);
                    add.Parameters.AddWithValue("@Width", width);
                    add.Parameters.AddWithValue("@Height", height);
                    add.Parameters.AddWithValue("@Category", categorie);
                    add.Parameters.AddWithValue("@Uploadtime", time);
                    add.Parameters.AddWithValue("@Price", prijs);
                    try
                    {
                        add.ExecuteNonQuery();
                        return "Succes!";
                    }
                    catch
                    {
                        return "Fail!";
                    }
                    finally
                    {
                        con.Close();
                    }
                }
            }
        }
        // methode om een category aan de database toe te voegen.
        public static string categorie(string category)
        {
            {
                using (SqlConnection con = new SqlConnection(ConfigurationManager.ConnectionStrings["fotosDB"].ConnectionString))
                {
                    con.Open();
                    string inse = "insert into [Categoriën]  values(@Categorie)";
                    using (SqlCommand add = new SqlCommand(inse, con))
                    {
                        add.Parameters.AddWithValue("@Categorie", category);
                        try
                        {
                            add.ExecuteNonQuery();
                            return "Category Toegevoegt";
                        }
                        catch
                        {
                            return "Error";
                        }
                        finally
                        {
                            con.Close();
                        }
                    }
                }
            }
        }
        // methode om een categorie te verwijderen
        public static string rmcategorie(string Categorie)
        {
            var connectionString = ConfigurationManager.ConnectionStrings["fotosDB"].ConnectionString;
            SqlConnection connection = new SqlConnection(connectionString);

            string sqlStatement = "DELETE FROM [Categoriën] WHERE Categorie = @Categorie";
            try
            {
                connection.Open();
                SqlCommand cmd = new SqlCommand(sqlStatement, connection);
                cmd.Parameters.AddWithValue("@Categorie", Categorie);
                cmd.CommandType = CommandType.Text;
                cmd.ExecuteNonQuery();
                return Categorie + "verwijderd!";
            }
            catch
            {
                return "Fout! " + Categorie + " komt niet in database voor!";
            }
            finally
            {
                connection.Close();
            }

        }
        // dit is een methode die voor encryptie zorgt van de fotos die upgeload zijn
        public static string EncryptFile(string inputFile, string outputFile, string skey)
        {
            try
            {
                using (RijndaelManaged aes = new RijndaelManaged())
                {
                    byte[] key = ASCIIEncoding.UTF8.GetBytes(skey);

                    
                    byte[] IV = ASCIIEncoding.UTF8.GetBytes(skey);

                    using (FileStream fsCrypt = new FileStream(outputFile, FileMode.Create))
                    {
                        using (ICryptoTransform encryptor = aes.CreateEncryptor(key, IV))
                        {
                            using (CryptoStream cs = new CryptoStream(fsCrypt, encryptor, CryptoStreamMode.Write))
                            {
                                using (FileStream fsIn = new FileStream(inputFile, FileMode.Open))
                                {
                                    int data;
                                    while ((data = fsIn.ReadByte()) != -1)
                                    {
                                        cs.WriteByte((byte)data);
                                    }
                                }
                            }
                        }
                        return "it worked";
                    }
                }
            }
            catch
            {
                return "it failed";

            }

        }
        /// <summary>
        /// Deze methode checkt of iemand admin is en daardoor de upload page wel of niet kan bezoeken.
        /// </summary>
        /// <param name="userName"></param>
        /// <returns></returns>
        public static bool isAdmin (string userName)
    {
        using (SqlConnection con = new SqlConnection(ConfigurationManager.ConnectionStrings["fotosDB"].ConnectionString))
        {
            bool isadmin;
            string result = "SELECT IsAdmin FROM [Users] WHERE UserName = @naam";
            SqlCommand showresult = new SqlCommand(result, con);
            showresult.Parameters.AddWithValue("naam", userName);
            con.Open();
            isadmin = Convert.ToBoolean(showresult.ExecuteScalar());
            con.Close();
            return isadmin;
        }

    }


        public static void SetWatermark(string filename, string workingDirectory)
        {
            //set a working directory 
            //string WorkingDirectory = @"C:\Users\Thomas\Documents\Visual Studio 2013\Projects\Project1\milanov\Pictures";

            //define a string of text to use as the Copyright message
            string Copyright = "© Groep 11 - Milanov project P3P";

            //create a image object containing the photograph to watermark
            using (Image imgPhoto = Image.FromFile(workingDirectory + "\\" + filename))
            {
                int phWidth = imgPhoto.Width;
                int phHeight = imgPhoto.Height;

                //create a Bitmap the Size of the original photograph
                using (Bitmap bmPhoto = new Bitmap(phWidth, phHeight, PixelFormat.Format24bppRgb))
                {

                    bmPhoto.SetResolution(imgPhoto.HorizontalResolution, imgPhoto.VerticalResolution);

                    //load the Bitmap into a Graphics object 
                    using (Graphics grPhoto = Graphics.FromImage(bmPhoto))
                    {
                        //create a image object containing the watermark
                        Image imgWatermark = new Bitmap(workingDirectory + "\\watermark\\watermark.png");
                        int wmWidth = imgWatermark.Width;
                        int wmHeight = imgWatermark.Height;

                        //------------------------------------------------------------
                        //Step #1 - Insert Copyright message
                        //------------------------------------------------------------

                        //Set the rendering quality for this Graphics object
                        grPhoto.SmoothingMode = SmoothingMode.AntiAlias;

                        //Draws the photo Image object at original size to the graphics object.
                        grPhoto.DrawImage(
                            imgPhoto,                               // Photo Image object
                            new Rectangle(0, 0, phWidth, phHeight), // Rectangle structure
                            0,                                      // x-coordinate of the portion of the source image to draw. 
                            0,                                      // y-coordinate of the portion of the source image to draw. 
                            phWidth,                                // Width of the portion of the source image to draw. 
                            phHeight,                               // Height of the portion of the source image to draw. 
                            GraphicsUnit.Pixel);                    // Units of measure 

                        //-------------------------------------------------------
                        //to maximize the size of the Copyright message we will 
                        //test multiple Font sizes to determine the largest posible 
                        //font we can use for the width of the Photograph
                        //define an array of point sizes you would like to consider as possiblities
                        //-------------------------------------------------------
                        int[] sizes = new int[] { 16, 14, 12, 10, 8, 6, 4 };

                        Font crFont = null;
                        SizeF crSize = new SizeF();

                        //Loop through the defined sizes checking the length of the Copyright string
                        //If its length in pixles is less then the image width choose this Font size.
                        for (int i = 0; i < 7; i++)
                        {
                            //set a Font object to Arial (i)pt, Bold
                            crFont = new Font("arial", sizes[i], FontStyle.Bold);
                            //Measure the Copyright string in this Font
                            crSize = grPhoto.MeasureString(Copyright, crFont);

                            if ((ushort)crSize.Width < (ushort)phWidth)
                                break;
                        }

                        //Since all photographs will have varying heights, determine a 
                        //position 5% from the bottom of the image
                        int yPixlesFromBottom = (int)(phHeight * .05);

                        //Now that we have a point size use the Copyrights string height 
                        //to determine a y-coordinate to draw the string of the photograph
                        float yPosFromBottom = ((phHeight - yPixlesFromBottom) - (crSize.Height / 2));

                        //Determine its x-coordinate by calculating the center of the width of the image
                        float xCenterOfImg = (phWidth / 2);

                        //Define the text layout by setting the text alignment to centered
                        StringFormat StrFormat = new StringFormat();
                        StrFormat.Alignment = StringAlignment.Center;

                        //define a Brush which is semi trasparent black (Alpha set to 153)
                        SolidBrush semiTransBrush2 = new SolidBrush(Color.FromArgb(153, 0, 0, 0));

                        //Draw the Copyright string
                        grPhoto.DrawString(Copyright,                 //string of text
                            crFont,                                   //font
                            semiTransBrush2,                           //Brush
                            new PointF(xCenterOfImg + 1, yPosFromBottom + 1),  //Position
                            StrFormat);

                        //define a Brush which is semi trasparent white (Alpha set to 153)
                        SolidBrush semiTransBrush = new SolidBrush(Color.FromArgb(153, 255, 255, 255));

                        //Draw the Copyright string a second time to create a shadow effect
                        //Make sure to move this text 1 pixel to the right and down 1 pixel
                        grPhoto.DrawString(Copyright,                 //string of text
                            crFont,                                   //font
                            semiTransBrush,                           //Brush
                            new PointF(xCenterOfImg, yPosFromBottom),  //Position
                            StrFormat);                               //Text alignment



                        //------------------------------------------------------------
                        //Step #2 - Insert Watermark image
                        //------------------------------------------------------------

                        //Create a Bitmap based on the previously modified photograph Bitmap
                        Bitmap bmWatermark = new Bitmap(bmPhoto);
                        bmWatermark.SetResolution(imgPhoto.HorizontalResolution, imgPhoto.VerticalResolution);
                        //Load this Bitmap into a new Graphic Object
                        Graphics grWatermark = Graphics.FromImage(bmWatermark);

                        //To achieve a transulcent watermark we will apply (2) color 
                        //manipulations by defineing a ImageAttributes object and 
                        //seting (2) of its properties.
                        ImageAttributes imageAttributes = new ImageAttributes();

                        //The first step in manipulating the watermark image is to replace 
                        //the background color with one that is trasparent (Alpha=0, R=0, G=0, B=0)
                        //to do this we will use a Colormap and use this to define a RemapTable
                        ColorMap colorMap = new ColorMap();

                        //My watermark was defined with a background of 100% Green this will
                        //be the color we search for and replace with transparency
                        colorMap.OldColor = Color.FromArgb(255, 0, 255, 0);
                        colorMap.NewColor = Color.FromArgb(0, 0, 0, 0);

                        ColorMap[] remapTable = { colorMap };

                        imageAttributes.SetRemapTable(remapTable, ColorAdjustType.Bitmap);

                        //The second color manipulation is used to change the opacity of the 
                        //watermark.  This is done by applying a 5x5 matrix that contains the 
                        //coordinates for the RGBA space.  By setting the 3rd row and 3rd column 
                        //to 0.3f we achive a level of opacity
                        float[][] colorMatrixElements = { 
												new float[] {1.0f,  0.0f,  0.0f,  0.0f, 0.0f},       
												new float[] {0.0f,  1.0f,  0.0f,  0.0f, 0.0f},        
												new float[] {0.0f,  0.0f,  1.0f,  0.0f, 0.0f},        
												new float[] {0.0f,  0.0f,  0.0f,  0.3f, 0.0f},        
												new float[] {0.0f,  0.0f,  0.0f,  0.0f, 1.0f}};
                        ColorMatrix wmColorMatrix = new ColorMatrix(colorMatrixElements);

                        imageAttributes.SetColorMatrix(wmColorMatrix, ColorMatrixFlag.Default,
                            ColorAdjustType.Bitmap);

                        //For this example we will place the watermark in the upper right
                        //hand corner of the photograph. offset down 10 pixels and to the 
                        //left 10 pixles

                        int xPosOfWm = ((phWidth - wmWidth) - 10);
                        int yPosOfWm = 10;

                        grWatermark.DrawImage(imgWatermark,
                            new Rectangle(xPosOfWm, yPosOfWm, wmWidth, wmHeight),  //Set the detination Position
                            0,                  // x-coordinate of the portion of the source image to draw. 
                            0,                  // y-coordinate of the portion of the source image to draw. 
                            wmWidth,            // Watermark Width
                            wmHeight,		    // Watermark Height
                            GraphicsUnit.Pixel, // Unit of measurment
                            imageAttributes);   //ImageAttributes Object

                        //Replace the original photgraphs bitmap with the new Bitmap
                        //imgPhoto = bmWatermark;
                        grPhoto.Dispose();
                        grWatermark.Dispose();

                        //save new image to file system.
                        bmWatermark.Save(workingDirectory + "\\demo\\demo_" + filename, ImageFormat.Jpeg);
                        bmWatermark.Dispose();
                        imgWatermark.Dispose();
                    }
                }
            }
        }

    }

}